Termination w.r.t. Q proof of TRS/Cimebig.trs

Termination w.r.t. Q of the following Term Rewriting System could be proven:

Q restricted rewrite system:
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.

↳ QTRS

  ↳ DependencyPairsProof

Q restricted rewrite system:
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.

Using Dependency Pairs [1,13] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

MEM₂(x, cons₂(y, l)) -> EQ₂(x, y)
*¹₂(*₂(x, y), z) -> *¹₂(y, z)
LOG'₁(1₁(x)) -> +¹₂(log'₁(x), 1₁(#))
PROD₁(app₂(l1, l2)) -> PROD₁(l2)
IFINTER₄(true, x, l1, l2) -> INTER₂(l1, l2)
-¹₂(0₁(x), 1₁(y)) -> -¹₂(-₂(x, y), 1₁(#))
SUM₁(app₂(l1, l2)) -> +¹₂(sum₁(l1), sum₁(l2))
INTER₂(l1, cons₂(x, l2)) -> MEM₂(x, l1)
LOG'₁(0₁(x)) -> LOG'₁(x)
*¹₂(x, +₂(y, z)) -> *¹₂(x, y)
GE₂(1₁(x), 0₁(y)) -> GE₂(x, y)
GE₂(0₁(x), 1₁(y)) -> GE₂(y, x)
*¹₂(*₂(x, y), z) -> *¹₂(x, *₂(y, z))
+¹₂(1₁(x), 1₁(y)) -> 0¹₁(+₂(+₂(x, y), 1₁(#)))
-¹₂(1₁(x), 0₁(y)) -> -¹₂(x, y)
-¹₂(0₁(x), 1₁(y)) -> -¹₂(x, y)
INTER₂(l1, app₂(l2, l3)) -> INTER₂(l1, l3)
+¹₂(+₂(x, y), z) -> +¹₂(y, z)
PROD₁(app₂(l1, l2)) -> PROD₁(l1)
*¹₂(1₁(x), y) -> 0¹₁(*₂(x, y))
*¹₂(1₁(x), y) -> +¹₂(0₁(*₂(x, y)), y)
EQ₂(0₁(x), 0₁(y)) -> EQ₂(x, y)
APP₂(cons₂(x, l1), l2) -> APP₂(l1, l2)
MEM₂(x, cons₂(y, l)) -> IF₃(eq₂(x, y), true, mem₂(x, l))
LOG'₁(0₁(x)) -> GE₂(x, 1₁(#))
SUM₁(app₂(l1, l2)) -> SUM₁(l1)
GE₂(0₁(x), 1₁(y)) -> NOT₁(ge₂(y, x))
INTER₂(app₂(l1, l2), l3) -> INTER₂(l1, l3)
LOG'₁(0₁(x)) -> +¹₂(log'₁(x), 1₁(#))
PROD₁(cons₂(x, l)) -> *¹₂(x, prod₁(l))
INTER₂(l1, app₂(l2, l3)) -> INTER₂(l1, l2)
PROD₁(cons₂(x, l)) -> PROD₁(l)
*¹₂(x, +₂(y, z)) -> *¹₂(x, z)
*¹₂(0₁(x), y) -> *¹₂(x, y)
+¹₂(0₁(x), 1₁(y)) -> +¹₂(x, y)
+¹₂(1₁(x), 0₁(y)) -> +¹₂(x, y)
IFINTER₄(false, x, l1, l2) -> INTER₂(l1, l2)
+¹₂(1₁(x), 1₁(y)) -> +¹₂(+₂(x, y), 1₁(#))
SUM₁(nil) -> 0¹₁(#)
EQ₂(1₁(x), 1₁(y)) -> EQ₂(x, y)
INTER₂(app₂(l1, l2), l3) -> INTER₂(l2, l3)
-¹₂(1₁(x), 1₁(y)) -> 0¹₁(-₂(x, y))
EQ₂(0₁(x), #) -> EQ₂(x, #)
EQ₂(#, 0₁(y)) -> EQ₂(#, y)
+¹₂(0₁(x), 0₁(y)) -> +¹₂(x, y)
-¹₂(0₁(x), 0₁(y)) -> 0¹₁(-₂(x, y))
LOG₁(x) -> LOG'₁(x)
INTER₂(l1, cons₂(x, l2)) -> IFINTER₄(mem₂(x, l1), x, l2, l1)
*¹₂(x, +₂(y, z)) -> +¹₂(*₂(x, y), *₂(x, z))
*¹₂(1₁(x), y) -> *¹₂(x, y)
+¹₂(0₁(x), 0₁(y)) -> 0¹₁(+₂(x, y))
MEM₂(x, cons₂(y, l)) -> MEM₂(x, l)
LOG'₁(1₁(x)) -> LOG'₁(x)
SUM₁(cons₂(x, l)) -> +¹₂(x, sum₁(l))
LOG₁(x) -> -¹₂(log'₁(x), 1₁(#))
GE₂(1₁(x), 1₁(y)) -> GE₂(x, y)
+¹₂(1₁(x), 1₁(y)) -> +¹₂(x, y)
-¹₂(0₁(x), 0₁(y)) -> -¹₂(x, y)
SUM₁(app₂(l1, l2)) -> SUM₁(l2)
INTER₂(l1, app₂(l2, l3)) -> APP₂(inter₂(l1, l2), inter₂(l1, l3))
+¹₂(+₂(x, y), z) -> +¹₂(x, +₂(y, z))
SUM₁(cons₂(x, l)) -> SUM₁(l)
LOG'₁(0₁(x)) -> IF₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
GE₂(#, 0₁(x)) -> GE₂(#, x)
INTER₂(cons₂(x, l1), l2) -> IFINTER₄(mem₂(x, l2), x, l1, l2)
PROD₁(app₂(l1, l2)) -> *¹₂(prod₁(l1), prod₁(l2))
INTER₂(app₂(l1, l2), l3) -> APP₂(inter₂(l1, l3), inter₂(l2, l3))
*¹₂(0₁(x), y) -> 0¹₁(*₂(x, y))
GE₂(0₁(x), 0₁(y)) -> GE₂(x, y)
INTER₂(cons₂(x, l1), l2) -> MEM₂(x, l2)
-¹₂(1₁(x), 1₁(y)) -> -¹₂(x, y)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

MEM₂(x, cons₂(y, l)) -> EQ₂(x, y)
*¹₂(*₂(x, y), z) -> *¹₂(y, z)
LOG'₁(1₁(x)) -> +¹₂(log'₁(x), 1₁(#))
PROD₁(app₂(l1, l2)) -> PROD₁(l2)
IFINTER₄(true, x, l1, l2) -> INTER₂(l1, l2)
-¹₂(0₁(x), 1₁(y)) -> -¹₂(-₂(x, y), 1₁(#))
SUM₁(app₂(l1, l2)) -> +¹₂(sum₁(l1), sum₁(l2))
INTER₂(l1, cons₂(x, l2)) -> MEM₂(x, l1)
LOG'₁(0₁(x)) -> LOG'₁(x)
*¹₂(x, +₂(y, z)) -> *¹₂(x, y)
GE₂(1₁(x), 0₁(y)) -> GE₂(x, y)
GE₂(0₁(x), 1₁(y)) -> GE₂(y, x)
*¹₂(*₂(x, y), z) -> *¹₂(x, *₂(y, z))
+¹₂(1₁(x), 1₁(y)) -> 0¹₁(+₂(+₂(x, y), 1₁(#)))
-¹₂(1₁(x), 0₁(y)) -> -¹₂(x, y)
-¹₂(0₁(x), 1₁(y)) -> -¹₂(x, y)
INTER₂(l1, app₂(l2, l3)) -> INTER₂(l1, l3)
+¹₂(+₂(x, y), z) -> +¹₂(y, z)
PROD₁(app₂(l1, l2)) -> PROD₁(l1)
*¹₂(1₁(x), y) -> 0¹₁(*₂(x, y))
*¹₂(1₁(x), y) -> +¹₂(0₁(*₂(x, y)), y)
EQ₂(0₁(x), 0₁(y)) -> EQ₂(x, y)
APP₂(cons₂(x, l1), l2) -> APP₂(l1, l2)
MEM₂(x, cons₂(y, l)) -> IF₃(eq₂(x, y), true, mem₂(x, l))
LOG'₁(0₁(x)) -> GE₂(x, 1₁(#))
SUM₁(app₂(l1, l2)) -> SUM₁(l1)
GE₂(0₁(x), 1₁(y)) -> NOT₁(ge₂(y, x))
INTER₂(app₂(l1, l2), l3) -> INTER₂(l1, l3)
LOG'₁(0₁(x)) -> +¹₂(log'₁(x), 1₁(#))
PROD₁(cons₂(x, l)) -> *¹₂(x, prod₁(l))
INTER₂(l1, app₂(l2, l3)) -> INTER₂(l1, l2)
PROD₁(cons₂(x, l)) -> PROD₁(l)
*¹₂(x, +₂(y, z)) -> *¹₂(x, z)
*¹₂(0₁(x), y) -> *¹₂(x, y)
+¹₂(0₁(x), 1₁(y)) -> +¹₂(x, y)
+¹₂(1₁(x), 0₁(y)) -> +¹₂(x, y)
IFINTER₄(false, x, l1, l2) -> INTER₂(l1, l2)
+¹₂(1₁(x), 1₁(y)) -> +¹₂(+₂(x, y), 1₁(#))
SUM₁(nil) -> 0¹₁(#)
EQ₂(1₁(x), 1₁(y)) -> EQ₂(x, y)
INTER₂(app₂(l1, l2), l3) -> INTER₂(l2, l3)
-¹₂(1₁(x), 1₁(y)) -> 0¹₁(-₂(x, y))
EQ₂(0₁(x), #) -> EQ₂(x, #)
EQ₂(#, 0₁(y)) -> EQ₂(#, y)
+¹₂(0₁(x), 0₁(y)) -> +¹₂(x, y)
-¹₂(0₁(x), 0₁(y)) -> 0¹₁(-₂(x, y))
LOG₁(x) -> LOG'₁(x)
INTER₂(l1, cons₂(x, l2)) -> IFINTER₄(mem₂(x, l1), x, l2, l1)
*¹₂(x, +₂(y, z)) -> +¹₂(*₂(x, y), *₂(x, z))
*¹₂(1₁(x), y) -> *¹₂(x, y)
+¹₂(0₁(x), 0₁(y)) -> 0¹₁(+₂(x, y))
MEM₂(x, cons₂(y, l)) -> MEM₂(x, l)
LOG'₁(1₁(x)) -> LOG'₁(x)
SUM₁(cons₂(x, l)) -> +¹₂(x, sum₁(l))
LOG₁(x) -> -¹₂(log'₁(x), 1₁(#))
GE₂(1₁(x), 1₁(y)) -> GE₂(x, y)
+¹₂(1₁(x), 1₁(y)) -> +¹₂(x, y)
-¹₂(0₁(x), 0₁(y)) -> -¹₂(x, y)
SUM₁(app₂(l1, l2)) -> SUM₁(l2)
INTER₂(l1, app₂(l2, l3)) -> APP₂(inter₂(l1, l2), inter₂(l1, l3))
+¹₂(+₂(x, y), z) -> +¹₂(x, +₂(y, z))
SUM₁(cons₂(x, l)) -> SUM₁(l)
LOG'₁(0₁(x)) -> IF₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
GE₂(#, 0₁(x)) -> GE₂(#, x)
INTER₂(cons₂(x, l1), l2) -> IFINTER₄(mem₂(x, l2), x, l1, l2)
PROD₁(app₂(l1, l2)) -> *¹₂(prod₁(l1), prod₁(l2))
INTER₂(app₂(l1, l2), l3) -> APP₂(inter₂(l1, l3), inter₂(l2, l3))
*¹₂(0₁(x), y) -> 0¹₁(*₂(x, y))
GE₂(0₁(x), 0₁(y)) -> GE₂(x, y)
INTER₂(cons₂(x, l1), l2) -> MEM₂(x, l2)
-¹₂(1₁(x), 1₁(y)) -> -¹₂(x, y)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [13,14,18] contains 14 SCCs with 26 less nodes.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

APP₂(cons₂(x, l1), l2) -> APP₂(l1, l2)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

APP₂(cons₂(x, l1), l2) -> APP₂(l1, l2)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(APP₂(x₁, x₂)) = x₁
POL(cons₂(x₁, x₂)) = 1 + x₂

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

GE₂(#, 0₁(x)) -> GE₂(#, x)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

GE₂(#, 0₁(x)) -> GE₂(#, x)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(#) = 0
POL(0₁(x₁)) = 2 + 2·x₁
POL(GE₂(x₁, x₂)) = 3·x₂

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

GE₂(1₁(x), 1₁(y)) -> GE₂(x, y)
GE₂(0₁(x), 0₁(y)) -> GE₂(x, y)
GE₂(1₁(x), 0₁(y)) -> GE₂(x, y)
GE₂(0₁(x), 1₁(y)) -> GE₂(y, x)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

GE₂(1₁(x), 1₁(y)) -> GE₂(x, y)
GE₂(0₁(x), 0₁(y)) -> GE₂(x, y)
GE₂(1₁(x), 0₁(y)) -> GE₂(x, y)
GE₂(0₁(x), 1₁(y)) -> GE₂(y, x)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(0₁(x₁)) = 3 + 3·x₁
POL(1₁(x₁)) = 3 + x₁
POL(GE₂(x₁, x₂)) = 3·x₁ + 3·x₁·x₂ + 3·x₂

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

EQ₂(0₁(x), #) -> EQ₂(x, #)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

EQ₂(0₁(x), #) -> EQ₂(x, #)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(#) = 0
POL(0₁(x₁)) = 2 + 2·x₁
POL(EQ₂(x₁, x₂)) = 3·x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

EQ₂(#, 0₁(y)) -> EQ₂(#, y)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

EQ₂(#, 0₁(y)) -> EQ₂(#, y)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(#) = 0
POL(0₁(x₁)) = 2 + 2·x₁
POL(EQ₂(x₁, x₂)) = 3·x₂

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

EQ₂(1₁(x), 1₁(y)) -> EQ₂(x, y)
EQ₂(0₁(x), 0₁(y)) -> EQ₂(x, y)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

EQ₂(1₁(x), 1₁(y)) -> EQ₂(x, y)
EQ₂(0₁(x), 0₁(y)) -> EQ₂(x, y)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(0₁(x₁)) = 3 + 2·x₁
POL(1₁(x₁)) = 3 + x₁
POL(EQ₂(x₁, x₂)) = 3·x₁ + 3·x₁·x₂ + 3·x₂

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

MEM₂(x, cons₂(y, l)) -> MEM₂(x, l)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

MEM₂(x, cons₂(y, l)) -> MEM₂(x, l)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(MEM₂(x₁, x₂)) = x₂
POL(cons₂(x₁, x₂)) = 1 + x₂

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

INTER₂(l1, cons₂(x, l2)) -> IFINTER₄(mem₂(x, l1), x, l2, l1)
INTER₂(l1, app₂(l2, l3)) -> INTER₂(l1, l3)
INTER₂(cons₂(x, l1), l2) -> IFINTER₄(mem₂(x, l2), x, l1, l2)
INTER₂(l1, app₂(l2, l3)) -> INTER₂(l1, l2)
IFINTER₄(true, x, l1, l2) -> INTER₂(l1, l2)
INTER₂(app₂(l1, l2), l3) -> INTER₂(l2, l3)
INTER₂(app₂(l1, l2), l3) -> INTER₂(l1, l3)
IFINTER₄(false, x, l1, l2) -> INTER₂(l1, l2)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

INTER₂(l1, cons₂(x, l2)) -> IFINTER₄(mem₂(x, l1), x, l2, l1)
INTER₂(l1, app₂(l2, l3)) -> INTER₂(l1, l3)
INTER₂(l1, app₂(l2, l3)) -> INTER₂(l1, l2)

The remaining pairs can at least be oriented weakly.

INTER₂(cons₂(x, l1), l2) -> IFINTER₄(mem₂(x, l2), x, l1, l2)
IFINTER₄(true, x, l1, l2) -> INTER₂(l1, l2)
INTER₂(app₂(l1, l2), l3) -> INTER₂(l2, l3)
INTER₂(app₂(l1, l2), l3) -> INTER₂(l1, l3)
IFINTER₄(false, x, l1, l2) -> INTER₂(l1, l2)

Used ordering: Polynomial interpretation [21]:

POL(#) = 0
POL(0₁(x₁)) = 0
POL(1₁(x₁)) = 0
POL(IFINTER₄(x₁, x₂, x₃, x₄)) = x₂·x₄ + 2·x₃·x₄ + x₄
POL(INTER₂(x₁, x₂)) = x₁·x₂ + x₂
POL(app₂(x₁, x₂)) = 1 + x₁ + x₂
POL(cons₂(x₁, x₂)) = 2 + 2·x₁ + 3·x₁·x₂ + 3·x₂
POL(eq₂(x₁, x₂)) = 0
POL(false) = 0
POL(if₃(x₁, x₂, x₃)) = 0
POL(mem₂(x₁, x₂)) = 0
POL(nil) = 0
POL(true) = 0

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

INTER₂(cons₂(x, l1), l2) -> IFINTER₄(mem₂(x, l2), x, l1, l2)
INTER₂(app₂(l1, l2), l3) -> INTER₂(l2, l3)
IFINTER₄(true, x, l1, l2) -> INTER₂(l1, l2)
INTER₂(app₂(l1, l2), l3) -> INTER₂(l1, l3)
IFINTER₄(false, x, l1, l2) -> INTER₂(l1, l2)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

INTER₂(cons₂(x, l1), l2) -> IFINTER₄(mem₂(x, l2), x, l1, l2)
INTER₂(app₂(l1, l2), l3) -> INTER₂(l2, l3)
IFINTER₄(true, x, l1, l2) -> INTER₂(l1, l2)
INTER₂(app₂(l1, l2), l3) -> INTER₂(l1, l3)
IFINTER₄(false, x, l1, l2) -> INTER₂(l1, l2)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(#) = 0
POL(0₁(x₁)) = 0
POL(1₁(x₁)) = 0
POL(IFINTER₄(x₁, x₂, x₃, x₄)) = 1 + x₁ + x₁·x₃ + x₂·x₄ + 2·x₃ + 3·x₃·x₄ + x₄
POL(INTER₂(x₁, x₂)) = 3·x₁ + 3·x₁·x₂
POL(app₂(x₁, x₂)) = 1 + x₁ + 3·x₂
POL(cons₂(x₁, x₂)) = 3 + x₁ + 3·x₂
POL(eq₂(x₁, x₂)) = 0
POL(false) = 3
POL(if₃(x₁, x₂, x₃)) = x₂ + 2·x₃
POL(mem₂(x₁, x₂)) = 1 + x₂
POL(nil) = 2
POL(true) = 2

The following usable rules [14] were oriented:

if₃(true, x, y) -> x
if₃(false, x, y) -> y
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

-¹₂(1₁(x), 0₁(y)) -> -¹₂(x, y)
-¹₂(0₁(x), 1₁(y)) -> -¹₂(x, y)
-¹₂(0₁(x), 0₁(y)) -> -¹₂(x, y)
-¹₂(0₁(x), 1₁(y)) -> -¹₂(-₂(x, y), 1₁(#))
-¹₂(1₁(x), 1₁(y)) -> -¹₂(x, y)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

-¹₂(1₁(x), 0₁(y)) -> -¹₂(x, y)
-¹₂(0₁(x), 0₁(y)) -> -¹₂(x, y)

The remaining pairs can at least be oriented weakly.

-¹₂(0₁(x), 1₁(y)) -> -¹₂(x, y)
-¹₂(0₁(x), 1₁(y)) -> -¹₂(-₂(x, y), 1₁(#))
-¹₂(1₁(x), 1₁(y)) -> -¹₂(x, y)

Used ordering: Polynomial interpretation [21]:

POL(#) = 0
POL(-₂(x₁, x₂)) = 0
POL(-¹₂(x₁, x₂)) = x₂
POL(0₁(x₁)) = 1 + x₁
POL(1₁(x₁)) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

-¹₂(0₁(x), 1₁(y)) -> -¹₂(x, y)
-¹₂(0₁(x), 1₁(y)) -> -¹₂(-₂(x, y), 1₁(#))
-¹₂(1₁(x), 1₁(y)) -> -¹₂(x, y)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

-¹₂(0₁(x), 1₁(y)) -> -¹₂(x, y)
-¹₂(0₁(x), 1₁(y)) -> -¹₂(-₂(x, y), 1₁(#))
-¹₂(1₁(x), 1₁(y)) -> -¹₂(x, y)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(#) = 0
POL(-₂(x₁, x₂)) = x₁
POL(-¹₂(x₁, x₂)) = x₁ + 3·x₁·x₂ + x₂
POL(0₁(x₁)) = 3 + x₁
POL(1₁(x₁)) = 3 + x₁

The following usable rules [14] were oriented:

-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
-₂(x, #) -> x
0₁(#) -> #
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(#, x) -> #

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

+¹₂(0₁(x), 0₁(y)) -> +¹₂(x, y)
+¹₂(1₁(x), 1₁(y)) -> +¹₂(x, y)
+¹₂(+₂(x, y), z) -> +¹₂(y, z)
+¹₂(1₁(x), 0₁(y)) -> +¹₂(x, y)
+¹₂(0₁(x), 1₁(y)) -> +¹₂(x, y)
+¹₂(+₂(x, y), z) -> +¹₂(x, +₂(y, z))
+¹₂(1₁(x), 1₁(y)) -> +¹₂(+₂(x, y), 1₁(#))

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

+¹₂(0₁(x), 0₁(y)) -> +¹₂(x, y)
+¹₂(1₁(x), 1₁(y)) -> +¹₂(x, y)
+¹₂(+₂(x, y), z) -> +¹₂(y, z)
+¹₂(1₁(x), 0₁(y)) -> +¹₂(x, y)
+¹₂(0₁(x), 1₁(y)) -> +¹₂(x, y)
+¹₂(1₁(x), 1₁(y)) -> +¹₂(+₂(x, y), 1₁(#))

The remaining pairs can at least be oriented weakly.

+¹₂(+₂(x, y), z) -> +¹₂(x, +₂(y, z))

Used ordering: Polynomial interpretation [21]:

POL(#) = 1
POL(+₂(x₁, x₂)) = 1 + x₁ + x₂
POL(+¹₂(x₁, x₂)) = x₁ + x₂
POL(0₁(x₁)) = 1 + x₁
POL(1₁(x₁)) = 3 + x₁

The following usable rules [14] were oriented:

+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(x, #) -> x
+₂(#, x) -> x
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
0₁(#) -> #

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

+¹₂(+₂(x, y), z) -> +¹₂(x, +₂(y, z))

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

+¹₂(+₂(x, y), z) -> +¹₂(x, +₂(y, z))

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(#) = 0
POL(+₂(x₁, x₂)) = 2 + 3·x₁ + 3·x₁·x₂ + 2·x₂
POL(+¹₂(x₁, x₂)) = 3·x₁ + 3·x₁·x₂ + x₂
POL(0₁(x₁)) = 0
POL(1₁(x₁)) = 0

The following usable rules [14] were oriented:

+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(x, #) -> x
+₂(#, x) -> x
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
0₁(#) -> #
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

SUM₁(app₂(l1, l2)) -> SUM₁(l1)
SUM₁(app₂(l1, l2)) -> SUM₁(l2)
SUM₁(cons₂(x, l)) -> SUM₁(l)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

SUM₁(app₂(l1, l2)) -> SUM₁(l1)
SUM₁(app₂(l1, l2)) -> SUM₁(l2)
SUM₁(cons₂(x, l)) -> SUM₁(l)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(SUM₁(x₁)) = 3·x₁ + 3·x₁²
POL(app₂(x₁, x₂)) = 3 + x₁ + 2·x₂
POL(cons₂(x₁, x₂)) = 3 + 2·x₂

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

*¹₂(*₂(x, y), z) -> *¹₂(y, z)
*¹₂(x, +₂(y, z)) -> *¹₂(x, z)
*¹₂(1₁(x), y) -> *¹₂(x, y)
*¹₂(x, +₂(y, z)) -> *¹₂(x, y)
*¹₂(0₁(x), y) -> *¹₂(x, y)
*¹₂(*₂(x, y), z) -> *¹₂(x, *₂(y, z))

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

*¹₂(*₂(x, y), z) -> *¹₂(y, z)
*¹₂(x, +₂(y, z)) -> *¹₂(x, z)
*¹₂(1₁(x), y) -> *¹₂(x, y)
*¹₂(x, +₂(y, z)) -> *¹₂(x, y)
*¹₂(*₂(x, y), z) -> *¹₂(x, *₂(y, z))

The remaining pairs can at least be oriented weakly.

*¹₂(0₁(x), y) -> *¹₂(x, y)

Used ordering: Polynomial interpretation [21]:

POL(#) = 0
POL(*₂(x₁, x₂)) = 3 + 3·x₁ + x₁·x₂ + 2·x₂
POL(*¹₂(x₁, x₂)) = 3·x₁ + x₁·x₂ + 2·x₂
POL(+₂(x₁, x₂)) = 3 + x₁ + x₂
POL(0₁(x₁)) = x₁
POL(1₁(x₁)) = 3 + x₁

The following usable rules [14] were oriented:

+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
*₂(#, x) -> #
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(x, #) -> x
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
+₂(#, x) -> x
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
0₁(#) -> #
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

*¹₂(0₁(x), y) -> *¹₂(x, y)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

*¹₂(0₁(x), y) -> *¹₂(x, y)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(*¹₂(x₁, x₂)) = x₁
POL(0₁(x₁)) = 1 + x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PROD₁(app₂(l1, l2)) -> PROD₁(l2)
PROD₁(cons₂(x, l)) -> PROD₁(l)
PROD₁(app₂(l1, l2)) -> PROD₁(l1)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

PROD₁(app₂(l1, l2)) -> PROD₁(l2)
PROD₁(cons₂(x, l)) -> PROD₁(l)
PROD₁(app₂(l1, l2)) -> PROD₁(l1)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(PROD₁(x₁)) = 3·x₁ + 3·x₁²
POL(app₂(x₁, x₂)) = 3 + 2·x₁ + x₂
POL(cons₂(x₁, x₂)) = 3 + 2·x₂

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

LOG'₁(1₁(x)) -> LOG'₁(x)
LOG'₁(0₁(x)) -> LOG'₁(x)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

LOG'₁(1₁(x)) -> LOG'₁(x)
LOG'₁(0₁(x)) -> LOG'₁(x)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(0₁(x₁)) = 3 + 3·x₁ + 3·x₁²
POL(1₁(x₁)) = 3 + x₁
POL(LOG'₁(x₁)) = 3·x₁ + 3·x₁²

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

Q DP problem:
P is empty.
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.